Image rendering method and apparatus

ABSTRACT

An image rendering method for an entertainment device for rendering a pixel at a viewpoint includes: for a first element of a virtual scene, having a predetermined surface at a position within that scene, obtaining a machine learning system previously trained to predict a factor that, when combined with a distribution function that characterises an interaction of light with the predetermined surface, generates a pixel value corresponding to the first element of the virtual scene as illuminated at the position; providing the position and a direction based on the viewpoint to the machine learning system; combining the predicted factor from the machine learning system with the distribution function to generate the pixel value corresponding to the illuminated first element of the virtual scene at the position; and incorporating the pixel value into a rendered image for display; where the obtaining step comprises: identifying a current or anticipated state of an application determining the virtual scene to be rendered; requesting a download of a machine learning system corresponding to the current or anticipated state, from among a plurality of machine learning systems corresponding to a plurality of states of the application, accessible via a remote server; and downloading the requested machine learning system.

BACKGROUND OF THE INVENTION Field of the Invention

The present invention relates to an image rendering method and apparatus.

Description of the Prior Art

The “background” description provided herein is for the purpose of generally presenting the context of the disclosure. Work of the presently named inventors, to the extent it is described in this background section, as well as aspects of the description which may not otherwise qualify as prior art at the time of filing, are neither expressly or impliedly admitted as prior art against the present invention.

Ray tracing is a rendering process in which paths of light are traced within a virtual scene. The interactions of each ray with objects or surfaces within the scene are then simulated. To achieve a degree of realism, typically this simulation takes account of material properties of these objects or surfaces, such as their colour and reflectivity.

As a result, ray tracing is a computationally expensive process. Furthermore, that cost varies from image frame to image frame, depending on what scene is being illuminated, by what lights, and from what viewpoint.

This makes maintaining a preferred frame rate for rendering such images difficult to achieve; for an average computational cost corresponding to an average image completion time (i.e. a frame rate), and a given variance around that average caused by ray tracing, then either the average image quality has to be set low enough that the variance only rarely impacts the frame rate, or if the average image quality is set close to a maximum for the preferred frame rate, then the consistency of that frame rate must be sacrificed when varying ray tracing demands fluctuate above the average.

Neither outcome is desirable, but cannot easily be avoided whilst the computational burden of the ray tracing process is data-driven and unpredictable.

The present invention seeks to address or mitigate this problem.

SUMMARY OF THE INVENTION

Various aspects and features of the present invention are defined in the appended claims and within the text of the accompanying description and include at least:

-   -   in a first instance, an image rendering method in accordance         with claim 1; and     -   in another instance, an entertainment device in accordance with         claim 15.

It is to be understood that both the foregoing general summary of the invention and the following detailed description are exemplary, but are not restrictive, of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

A more complete appreciation of the disclosure and many of the attendant advantages thereof will be readily obtained as the same becomes better understood by reference to the following detailed description when considered in connection with the accompanying drawings, wherein:

FIG. 1 is a schematic diagram of an entertainment device in accordance with embodiments of the present description;

FIG. 2 is an illustration of a ray-traced object in accordance with embodiments of the present description;

FIG. 3 is a schematic diagram of components contributing to the ray-traced object in accordance with embodiments of the present description;

FIG. 4 is a schematic diagram of distribution functions associated with respective components in accordance with embodiments of the present description;

FIG. 5 is a schematic diagram of a scattering distribution in accordance with embodiments of the present description;

FIG. 6 is a schematic diagram of a training scheme for a machine learning system in accordance with embodiments of the present description;

FIG. 7 is a schematic diagram of a render path for a rendered image in accordance with embodiments of the present description;

FIG. 8A is a schematic diagram of a machine learning system in accordance with embodiments of the present description;

FIG. 8B is a schematic diagram of part of a machine learning system in accordance with embodiments of the present description;

FIG. 9 is a flow diagram of an image rendering method in accordance with embodiments of the present description;

FIG. 10 is a flow diagram of an image rendering method in accordance with embodiments of the present description;

FIG. 11 is a schematic diagram of a method of training in accordance with embodiments of the present description.

DESCRIPTION OF THE EMBODIMENTS

An image rendering method and apparatus are disclosed. In the following description, a number of specific details are presented in order to provide a thorough understanding of the embodiments of the present invention. It will be apparent, however, to a person skilled in the art that these specific details need not be employed to practice the present invention. Conversely, specific details known to the person skilled in the art are omitted for the purposes of clarity where appropriate.

Embodiments of the present description seek to address or mitigate the above problem by using a machine learning system that learns the relationship between pixel surface properties and rendered pixels for a given object or scene; by using such a machine learning system, it is then possible to approximate a ray traced render of the object or scene based on a relatively consistent computational budget (that of running the machine learning system).

Different machine learning systems can be trained for different scenes, locations or parts thereof, or for different objects or materials for use within one or more scenes, as explained later herein.

The machine learning systems are comparatively small (typically in the order of 100 KB to 1 MB) and so for the purposes of being run by a GPU (30), may be pulled into memory and subsequently discarded like a texture of the scene. The systems can be run by shaders of the GPU. It will also be appreciated that in principle the machine learning systems could alternatively or in addition by run by a CPU (20) or by a general or specialist co-processor, such as a neural network processor or an ASIC.

Referring now to the drawings, wherein like reference numerals designate identical or corresponding parts throughout the several views, FIGS. 2-7 illustrate the problem space within which the machine learning system is trained.

FIG. 2 is a high-quality ray-traced render 200 of an example object or scene, in this case a car on a dais.

FIG. 3 illustrates the different contributing components behind this render. Firstly, a diffuse lighting component 200-D typically captures the matt colours of the surface and the shading caused by the interaction of light and shape, whilst secondly a specular lighting component 200-S captures the reflectivity of the surface, resulting in glints and highlights. Optionally one or more additional components can be included, such as a sheen or ‘coat’ 200-C, which is a second outer surface that may comprise additional gloss or patterning. Variants of such a coat may allow for partial transparency and/or partial diffusion in a manner similar to skin or fabric, for example. Each of these components can be conventionally generated using a respective ray tracing process.

These components sum additively to form the overall image previously seen in FIG. 2. It will be appreciated that whilst typically 2 or 3 such components will contribute to a render, in come circumstances there may be fewer (for example if just a diffuse component is desired) or more (for example when the object is also translucent and so requires a transmissive component).

FIG. 4 next includes the material properties of the object that give rise to the above contributing components of the image.

The material property is expressed as a so-called bidirectional scattering distribution function (BSDF) or bidirectional reflectance distribution function (BRDF).

A BRDF defines how light is reflected at an opaque surface, whilst similarly a BSDF defines the probability that a ray of light will be reflected or scattered in a particular direction. Hence a BRDF or BSDF is a function that describes the lighting properties of a surface (excluding the incoming/outgoing radiance itself). Other functions may also be used as appropriate, such as a bidirectional transmittance distribution function (BTDF), defining how light passes through a material.

Referring also to FIG. 5, in a typical ray tracing application, for a set of rays (e.g. from a compact light source) the application computes the incoming radiance (itself either direct or previously reflected) onto a point on the model having a particular BSDF, BRDF, and/or BTDF. The incoming radiance is combined (e.g. multiplied) with the BSDF, BRDF, or BTDF for a particular contributing component response, and the result is added to the pixel value at that point on the model. As shown in FIG. 5, a typical scattering pattern for ray path ω_(i) in a BSDF will have a bias towards a mirror reflection direction ω_(a), but may scatter in any direction. Accurately modelling such behaviour is one reason ray tracing can be computationally expensive.

Using the colour information of the model at respective points and the corresponding BSDF, BRDF and/or BTDF for that point (i.e. for a particular material represented by a given point), the behaviour of the rays for a given final viewpoint can thus be calculated, with the ray reflectance or scattering for example determining the realistic distribution of glints and highlights on the surface of the vehicle.

Separate BSDFs, BRDFs, or BTDFs may be used for each contributing component; hence as a non-limiting example a BSDF may be used for the diffuse component, a BRDF for the specular component and in this example also a for the coat component (though a BTDF could also be used for such a coat component). It will be appreciated that either a BSDF, BRDF, or BTDF may be used as appropriate, and so hereinafter a reference to a BSDF encompasses a reference to a BRDF or a BTDF as appropriate, unless otherwise stated.

As shown in FIG. 4, performing ray tracing using the colour properties of the object and diffuse material properties of a BSDF (200-BSDF-D) results in the diffuse image component 200-D. Similarly using the specular or reflective material properties of a BSDF (200-BSDF-S) results in the specular image component 200-S. Likewise the material properties of a BSDF (200-BSDF-C), in this case typically also specular, results in a coat image component 200-C. Combining these components results in the final ray traced image 200.

The problem however, as previously stated, is that calculating the reflected and scattered paths of rays as they intersect with different surfaces having different BSDFs, and summing the results for each pixel of a scene at a particular viewpoint, is both computationally expensive and also potentially highly variable.

Embodiments of the present description therefore seek to replace the ray tracing step of FIG. 4 with something else that has a more predictable computational load for a suitable quality of final image.

Referring now also to FIG. 6, in embodiments of the present description, a respective machine learning system is provided for each contributing component of the image (e.g. diffuse, specular, and optionally coat or any other contributing component).

The machine learning system is typically a neural network, as described later herein, that is trained to learn a transform between the BSDF (e.g. 200-BSDF-D) and the ray-traced ground truth (e.g. 200-D) of the contributing component of the image, for a plurality of images at different viewpoints in the scene.

Put another way, if the ray traced image (or one of the contributing components) is a combination of how lighting plays over an object and the BSDF describing how that object reacts to light, then by taking the ray traced image and uncombining it with the BSDF, the result is a quality that may be referred to as ‘radiance’ or ‘shade’, but more generally describes how the light plays over the object (as computed in aggregate by the ray tracing process).

If the machine learning system or neural network can learn to predict this quality, then it can be combined again with the BSDF to produce a predicted image approximating the ray-traced image. The network may thus be referred to as a neural precomputed light model or NPLM network.

More specifically, for a given position on a hypothetical image of an object, and a direction of view, the machine learning system or neural network must learn to output a value that, when combined with the BSDF for that same position/pixel, results in a pixel value similar to that which would arise from raytracing the image at that pixel. Consequently during training it generates an internal representation of the lighting conditions (e.g. due to point lights or a skydome) and surface lighting properties implied from the training images.

Hence in an example embodiment, an image may be rasterised or otherwise generated at a given viewpoint, which would fill the image with pixels to then be illuminated. For each of these notional pixels there is a corresponding 3D position in the scene for which the appropriate ‘radiance’ or shade′ can be obtained using the NPLM network.

FIG. 6 shows a training environment for such a network, and specifically as an example only, a network 600-D for the diffuse contributing component.

The inputs to the network for the diffuse contributing component are an (x,y,z) position 610 on the object or scene (for example corresponding to a pixel in the image) and the normal 620 of the object/scene at that point. The normal N is used instead of the viewpoint direction because for the diffuse contributing component, the illuminance can be considered direction/viewpoint independent, and so the normal, as a known value, can be used for consistency. These inputs are illustrated notionally in FIG. 6 using representative values of each for the car image in the present explanatory example.

Optionally additional inputs may be provided (not shown), such as a roughness or matt-to-gloss scalar value that may optionally be derived from the relevant BSDF.

The output of the NPLM network (as explained later herein) is a learned quality of light or illuminance 630 for the input position that, when combined 640 with the relevant diffuse BSDF (200-BSDF-D) for the same position produces a predicted pixel value for the (x,y) position in a predicted image 650.

FIG. 6 illustrates that the per-pixel difference between the predicted pixel and the ground truth pixel of a target ray-traced diffuse component 200-D is used as the loss function for training the network, but this is not necessary; rather, the ground truth image can be uncombined with the BSDF (i.e. by performing an inverse function) to produce an proxy for how the ray traced light cumulatively affected the object in the image for each (x,y) pixel, and this is the quality that the network is training to learn.

Hence the error function for the network is based on the difference between its single pixel (x,y) output value and the corresponding single (x,y) pixel of the ground truth image when uncombined from the corresponding BSDF for that position.

Since the pixels of the ground truth image can be uncombined from the corresponding BSDF for each position once in advance, the network can be trained without needing to combine its own output with any BSDF to generate an actual predicted image pixel. This reduces the computational load of training.

As noted above, the learned quality output by the trained neural network captures how the light in the environment plays over the object or scene as a function of the position of surfaces within the scene and as a function of viewpoint. As such it effectively generates an internal representation of a light map for the scene and a surface response model. How this occurs is discussed in more detail later herein.

Referring now to FIG. 7, in summary for each contributing component of the final output image, a machine learning system is trained to perform a transform that is applied to the BSDF local to the position on the object/scene for that contributing component. The transform is a trained function, based on the (x,y,z) position of points on the object/scene and a direction value. As noted previously, depending on the number of contributing components of the final image, there may be any or one, two, three, four or possibly more machine learning systems employed. The term ‘trained function’ may be used hereafter to refer to a machine learning system that has learned such a transform.

As noted for the diffuse component the direction value can be assumed to equal the normal at a given point as the diffuse shading is assumed to be direction-invariant.

Meanwhile for the specular component, which is at least partially reflective and so will vary with view point, the direction value is or is based on the viewing angle between the (x,y) position of a current pixel at the image view point (which will have a position in the virtual space) and the (x,y,z) position of the object as input to the machine learning system, thereby providing a viewpoint dependent relationship between the input point on the scene surface and the current pixel for which the learned quantity is to be output.

In this case the coat component is also specular and so uses a similar viewpoint or viewpoint based direction for an input as well.

The direction value for direction dependent components may thus be the view direction between the output pixel position and the object surface position, or a value based on this, such as the surface mirrored viewpoint direction (i.e. the primary direction that the viewpoint direction would reflect in, given the normal of the surface at the input position). Any suitable direction value that incorporates information about the viewpoint direction may be considered.

In each case, the trained function encapsulates the learned quality, as described previously herein. Combining the appropriate BSDF with the network output for each position allows the shaded images for each component to be built up. Alternatively or in addition combining the pixel values for the shaded images from each component generates the final output.

It will be appreciated that during the rendering of an image, not all of the image may be subject to ray tracing, and similarly not all of an image may be generated using the above techniques. For example, NPLM networks may be trained for specific objects or materials based on ground truth ray traced images with representative lighting.

When these objects or materials are to be subsequently rendered in real time using the apparent ray tracing provided by the trained functions described herein, the relevant NPLM networks are loaded into memory and run for the relevant surface positions and viewing directions in the scene to produce their contributions to the relevant pixels, when combined with the appropriate BSDFs. Other pixels may be rendered using any other suitable techniques (including ray tracing itself).

Typically the appropriate the machine learning system(s) are selected and loaded into a memory used by the GPU based on the same asset identification scheme used for selecting and loading a texture for the object or material. Hence for example if an object has an ID ‘1234’ used to access associated textures, then this ID can also be associated with the relevant machine learning system(s). Conversely if a texture has an ID ‘5678’ that is associated with an object (e.g. where the texture represents a material common to plural objects), then this ID can also be associated with the relevant machine learning system(s). In this way the entertainment device can use a similar process to load the machine learning systems as it does to load the textures. It will be appreciated that the actual storage and access techniques may differ between textures and machine learning systems, particularly if textures are stored using lossy compression that would impact on the operation of a decompressed machine learning system. Hence the machine learning system may be stored without compression or using lossless compression, or lossy compression where the degree of loss is low enough that the decompressed machine learning system still operates adequately; this can be assessed by comparing the output error/cost function of the machine learning system for incremental degrees of loss in compression, until the error reaches an absolute or relative (to the uncompressed machine learning system) quality threshold.

Turning now to FIG. 8A, in embodiments of the present description, the machine learning system or NPLM network may be any suitable machine learning system. Hence for example a single neural network may be trained using the position and viewpoint direction as inputs, and generate RGB values for the learned property as outputs.

However, a particularly advantageous network comprises a distinct split architecture.

As shown in FIG. 8A, in a non-limiting example the network comprises two parts. The first part may be thought of as the position network, whilst the second part may be thought of as the direction network.

Each of these networks may have 3 or more layers, and use any suitable activation function.

The position network receives the previously mentioned (x, y, z) position for a point in the object/scene as input, and outputs an interim representation discussed later herein.

The direction network receives this interim representation and also the direction input (e.g. the normal, or the pixel viewpoint or surface point mirrored pixel viewpoint direction or other viewpoint based direction value, as appropriate) for example in a (θ, ϕ) format, or as a normalised (x, y, z) vector, or similar. It outputs RGB values corresponding to the previously mentioned leaned quantity for the (x,y) position (and hence pixel viewpoint) of a current pixel in an image to be rendered from a virtual camera position in a space shared with the object/scene.

Hence in a non-limiting example, the position network has 3 layers, with 3 input nodes (e.g. for the x, y, z position) on the first layer, 128 hidden nodes on the middle layer, and 8 outputs on the final layer.

Whilst any suitable activation function may be chosen for the network, a rectified linear unit (ReLU) function has been evaluated as a particularly effective activation function between the layers of the position network. It generalizes well to untrained positions and helps to avoid overfitting.

Similarly in the non-limiting example, the direction network has 4 layers, with the 8 outputs of the position network and 2 or 3 additional values for the direction feeding into 128 nodes on a first layer, then feeding on to two further layers of 128 nodes, and a final 3 outputs on the final layer corresponding to R,G,B values for the learned quantity at the current pixel. This could then combined (e.g. multiplied) with the BSDF for that position to get the final pixel contribution from this trained function (e.g. diffuse, specular etc), though as noted previously this is not required during training.

Whilst any suitable activation function may be chosen for the direction network, a sine function has been evaluated as a particularly effective activation function between the layers of the direction network. Because the light behaviour variation in the angular domain is large and contains details at many angular frequencies, but is based on a low dimensional input (e.g. a normalised x,y,z vector), the sine activation function has been found to be particularly good.

Notably therefore the two halves of the network may use different activation functions.

The network however is treated as a split-architecture network rather than as two separate networks because notably the training scheme only has one cost function; the error between the RGB values output by the direction network and the target values from the corresponding pixel of the ground truth ray traced image, after being uncombined with the appropriate BSDF.

This error is back-propagated through both networks; there is no separate target value or cost function for the position network. Hence in practice the output layer of the position network is really a hidden layer of the combined network, augmented with additional inputs of direction values, and representing a transition from a first activation function to a possible second and different activation function within the layers.

As noted previously, the neural network builds a light model for the lit object, material, or scene. In particular, in the non-limiting example above the position network effectively sorts the (x, y, z) positions into lighting types (e.g. bright or dark, and/or possibly other categories relating to how the light interacts with the respective BSDF, such as relative reflectivity or diffusion); the interim representation output by this part may be thought of as an N-dimensional location in a lighting space characterising the type of light at the input position; it will project positions in different parts of the scene to the same N-dimensional location if they are lit in the same way. A position network trained for a specular component may have more outputs that one for a diffuse component; for example 32 outputs compared to 8, to take account of the greater variability in types of lighting that may occur in the specular component.

The direction network then models how light the light model behaves when viewed in the surface at the input position at a certain input angle for the lit object, material, or scene, to generate the learned property for that location in the image.

Hence in summary, the position and direction networks are trained together as one to predict a factor or transform between a BSDF descriptive of a surface property, and the desired rendered image of that surface. The networks can then be used instead of ray tracing for renders of that surface. Typically but not necessarily the networks are trained on just one contributing component of the image, such as the diffuse of specular component, with a plurality of networks being used to produce the components needed for the final image or image portion, although this is not necessary (i.e. in principle a network could be trained on a fully combined image or a combination of two or more contributing components, such as all specular or all diffuse contributions).

Training

The network is trained as described elsewhere herein using a plurality of ray traced images of the object, scene, or surface taken from a plurality of different viewpoints. This allows the network to learn in particular about how specular reflections change with position. The viewpoints can be a random distribution, and/or may for example be selected (or predominantly selected) from within a range of viewpoints available to the user when navigating the rendered environment, known as the view volume; i.e. the volume of space within which viewpoints can occur, and so will need to be included in the training.

In an embodiment of the present description, the training data can be generated as follows.

It will be appreciated that for any machine learning system the training data used to train the system can be key to its performance. Consequently, generating training data that leads to good performance is highly beneficial.

As described elsewhere herein, the training data for the NPLM systems described herein is based on a set of high quality rendered images of a scene/object/material/surface (hereafter generically referred to as a scene), typically uncombined with one or more relevant distribution functions (e.g. a BSDF, BRDF, or the like as described elsewhere herein) so that the learned quality referred to herein can be provided as a direct training target, removing the computational burden of generating predicted images during training, and also ensuring that the error function is not derived at one remove from the output of the NPLM itself.

Different NPLMs may handle view dependent and view independent shading effects (e.g. diffuse, specular, etc), and so typically a single view of an object in a scene is not sufficient if the object has view dependent shading (e.g. specularity, or a mirror reflection, etc.).

Consequently the number and location of training data images can depend on not only the geometry of the scene (e.g. if an object is visible within the view volume), but potentially also the material properties of the objects in the scene also.

Hence in an embodiment of the present description, the NPLM training data, in the form of images of the scene taken at a plurality of camera viewpoints, can be generated at least in part based on the materials in the scene (e.g. material properties such as light response properties like a diffuse or specular response, but potentially also other material properties such as surface complexity—e.g. the present of narrow or broad spatial frequency components, structurally and/or texturally).

Notably these images are typically generated from a 3rd party high quality renderer, to which access to internal data is not available. Hence only the final complete image may be available, and not any information (or control) about specific cast rays or their directions when performing shading within an image.

It is therefore desirable to generate and use a set of images that efficiently capture the appearance of the scene, for preferably all valid views within the view volume, for the purposes of training.

Referring now to FIG. 11, to this end, in a step 1110 firstly a set of camera locations within the viewing volume are used to render a set of low resolution images. The locations may be equidistant or randomly distributed on a sphere around the scene (if it can be viewed from any angle, e.g. as a manipulable object), or on a hemisphere around the scene (if it is based on the virtual ground, and so not viewable from underneath), or on a ring around the scene (if it is viewed from a ground based viewpoint, e.g. a first person view of an avatar). Such a ring may be at a fixed height corresponding to the avatar viewpoint, or may occupy a height range, e.g. as a viewing cylinder encompassing one or more of a crouch and jump height for the avatar viewpoint.

Step 1110 is illustrated in FIG. 11 with an orbit (ring) of camera positions around the example car object.

The number of camera locations in this initial set may as few as one, but is typically three or more, and more typically is in the order of tens or hundreds. For example, one camera per degree of orbit would result in 360 cameras. In the present example, 200 cameras are used as a non-limiting number.

The resolution per image is low; for example 128×84 pixels. An example image is shown for step s1120.

Notably for each pixel of each image, in step s1130 metadata is associated with it comprising the 3D position of the scene surface corresponding to the pixel, the normal of the scene surface corresponding to the pixel, and optionally a material ID or similar material surface identifier or descriptor, such as a texture ID or object ID.

In a first instance of a viewpoint selection process, the 3D positions of the scene surfaces rendered by pixels in some or typically all of these low resolution images are collated to identify which positions within the scene are visible within the first set of camera positions. These are the 3D positions on which the NPLM would benefit from being trained on.

Hence optionally, for each 3D position identified as being rendered in at least one of the initial low resolution images, a new position in 3D space is calculated as offset from that position along the surface normal. The distance of the offset from the surface is a variable that can be modified. This new position is a candidate viewpoint for a virtual camera to generate a high quality (e.g. high resolution ray traced) render.

However, this may result in a large number of potential high quality ray-traced renders to generate as training images, which would be computationally burdensome, and might also include significant redundancy when used as a training set for the NPLM.

Consequently in a first instance it is desirable to filter or cull these candidate viewpoint positions in some manner that is relevant and useful to the training of the NPLM on the scene.

In particular, it is beneficial to have more training examples for parts of the scene that comprise view dependent materials (e.g. specular or shiny) than view independent materials (e.g. diffuse or matt).

Accordingly, one of two approaches may be taken.

In a first approach, in step 1140 for each of the candidate viewpoints corresponding to a normal at a surface position, the corresponding material property of the surface at that position is reviewed. As noted above, in particular its diffuse or specular response, or it translucency or the like, may be used.

In practice, this can be done by use of a look-up table associating the material ID or similar with a value indicating how diffuse or specular (e.g. matt or shiny) the material surface is. More particularly, this property can be represented, as a non-limiting example, by a value ranging from 0 for completely diffuse to 1 for a mirror reflection. This can be treated as an input to a probability function, so that specular or shiny (view dependent) materials have a comparatively high probability, and diffuse or matt (view independent) materials have a comparatively low probability.

The probability function is then used to retain candidate camera positions; a higher proportion of camera positions facing specular surfaces will therefore be retained, compared to diffuse surfaces.

Conversely if the value conventions are reversed (e.g. low and high probabilities are reversed) then the probability function can be used to cull candidate camera positions to the same effect.

In a second approach, alternatively or in addition in step s1140 the variability of pixel values corresponding to the same 3D position of the scene surface as viewed in the low resolution images can be evaluated, to determine a pixel value variance for each captured 3D position. In this way, view invariant (e.g. diffuse or heavily shadowed) surface positions will have a low variance (i.e. pixels showing that position in different low resolution images will be similar), whilst view dependent (e.g. specular or shiny) surface positons will have a high variance (i.e. pixels showing that position in different low resolution images will show a wider range of values for example as some catch glints or reflections of light). This variance, or a normalised version thereof, can again be used as an input to a probability function so that specular or shiny (view dependent) materials have a comparatively high probability, and diffuse or matt (view independent) materials have a comparatively low probability.

Hence in either case, in step s1140 an estimate of the view dependency of the light responsiveness of the material at each captured 3D position in the view volume is obtained (either based on material property or pixel variability, or potentially both), and this can be used as an input to a probability function.

The probability function is then used at step s1150 to decide whether a respective candidate viewpoint is kept or culled, with viewpoints centred on view dependent surfaces being retained more often than those centred on view independent surfaces.

The output range of this probability function can be tuned to generate approximately the desired overall number of camera viewpoints for training based on the original number of possible candidates and the final desired number, or alternatively a probability function can be applied for successive rounds of retention/culling until the number of remaining camera viewpoints is within a threshold value of the desired number.

In either case the result is a manageable number of camera viewpoints randomly distributed over the desired viewing volume, but with a variable probability density that is responsive to the material property (e.g. shininess or otherwise) of the material immediately centred in front of the camera. This is illustrated by the constellation of surviving points in the figure for step s1150. In practice, the camera positions can be further away from the object/scene surface than is shown in this figure, but the points have been placed close to the surface in the figure in order to illustrate their distribution.

The amount of the manageable number of camera viewpoints can be selected based on factors such as the desired performance of the resulting NPLM, the computational burden of generating the high quality ray traced images and training the NPLM on them, memory or storage constraints, and the like. A typical manageable number for training purposes may be, as a non-limiting example, between 10 and 10,000, with a typical number being 200 to 2000.

Finally, in step s1160 the images are rendered at the surviving viewpoints. Optionally, as shown in FIG. 11, these renders are generated using a wider angle virtual lens than the lens used for the initial low resolution images or the lens used during game play.

This tends to result in rendering too much of the scene (i.e. parts that are not directly visible from the view volume points); this tends to make the NPLM output more robust, particularly for view positions near the edges of the view volume, and also in case of unexpected extensions of the view volume e.g. due to object clipping in game, or minor design modifications.

Whilst the above approach generated candidate camera viewpoints based on the normals of the scene surface that were captured in the initial low resolutions images, this is not the only potential approach.

One possible issue with the above approach is that whilst a view-invariant position in the scene may be imaged by a camera pointing toward it along the normal at that position, it is only rendered from different angles in other images that at nearby positions, and in turn these angles are dictated by the normal of the scene surface at those positions. As a result whilst there may be comparatively more images captured on and near view dependent parts of the scene, the images themselves are potentially unduly influenced by the geometry of the scene itself.

Accordingly, returning to the initial low resolution images, in another instance of the viewpoint selection process, a potential viewpoint position may be considered for each pixel of each low resolution image (or at least those pixels that represent a surface in the scene). In the above example of 200 images at 128×84 pixels, this equates to up to 1.6 million candidates. These images typically capture multiple instances of a given position on the scene from different angles, independent of the topology of the scene itself. As a result the training set is potentially more robust.

Again the surface material (and/or pixel variance) derived view dependency of the surface position corresponding to a given pixel within a low resolution image, and hence to a candidate viewpoint, can be used to drive a probability of retaining or culling that viewpoint. In this way the 1.6 million candidate viewpoints can again be culled down to a manageable number.

In this case, because there can be multiple views of the same position within the scene, it is possible that the resulting distribution of camera views is biased towards those positions within the scene that are most visible, as opposed to only most view dependent; for example, if one (diffuse) position in the scene is visible in 20 times more images than one (specular) position, then even though it is more likely that the viewpoints looking at the diffuse position will be culled, because there are twenty times more of them the eventual result may be that there are more images of the diffuse position than the shiny one.

Hence optionally, the probability of retaining or culling a viewpoint can be normalised based on how many viewpoints are centred on the same position in the scene (albeit from different angles). This normalisation may be full (so in the above example, the probability of retaining an image of the diffuse position is made 20 times less, so the effect of the number of views is removed). Alternatively the normalisation may be partial; so that for example, the probability of retaining an image of the diffuse position is only made 10 times less so the effect of the number of views is significantly reduced, but not totally removed; this would mean that areas that are potentially seen a lot by the user would also get more training examples, independent of whether they also got more training examples due to being view dependent (e.g. specular/shiny).

In principle, both sets of viewpoints (surface normal based viewpoints and low resolution image pixel based viewpoints) could be generated and culled to create a combined viewpoint set prior to generating high quality ray traced renders for training purposes; indeed in any case there is likely to be a subset of low resolution image pixel based viewpoints that in effect are coincident with the normals of at least some of the visible surface positions.

-   -   Variant training techniques

The above second approach optionally considers the issue of compensating for multiple views of the same position in the scene when culling available viewpoints. In addition to enabling control of training bias, it also reduces training times for this second approach by reducing repetitions for certain positions in the scene.

However, alternatively or in addition the training time can be (further) reduced as follows.

As before, select an initial set of viewpoints within (or on the surface of) a view volume.

Now optionally, generate the initial low resolution images for a set of positions within the view volume.

Now optionally, then generate candidate viewpoints either based on normals of the positions in the scene found in the low resolution images, and/or based on lines between pixels of the low resolution images and the represented positions in the scene, as described previously herein.

Again optionally, these viewpoints can be culled with a probability based on the degree of specularity/diffusion of the respective position in the scene. Further optionally, where there are multiple images centred on a respective position, the probability can be modified to at least partially account for this.

Hence, depending on the approach taken, the result is a generated series of viewpoints—either the original distribution optionally used to generate the low resolution images, or a distribution arising from one of the above generation-and-culling techniques.

In either case, in an embodiment of the description, once a viewpoint is generated (and optionally confirmed as not being culled, as appropriate), it is provided to or queued for a ray tracing process to generate the high quality image, optionally in a wide angle form as described elsewhere herein.

Training on generated image begins when a respective image is complete; hence there is a parallel process of generating training images (which due to being ray-traced images, takes some time) and training on those images (which can also take some time). This avoids the issue of having to wait for the complete training set to be generated before training can begin.

Optionally, where viewpoints have been generated, or where generated viewpoints are selected to determine if they are to be culled, the selection of a viewpoint from those available can be random, so that the eventual production sequence of ray traced images is also random within the final set of viewpoints being used.

This reduces the chance of the NPLM becoming initially over trained on one section of the scene, and also means that if, for example, the training has to be curtailed due to time constraints, the NPLM will still have been exposed to a diverse set of views of the scene.

In another variant training technique, if control of the ray tracing application is available and allows it, then optionally only a subset of pixels for an image from a given viewpoint need be rendered; whether based on the original set of viewpoints or a viewpoint that was not culled, there may be parts of a scene within a given image that have been rendered a number of times in other images within the training set. For example, if a position in the scene has already been rendered more than a threshold number of times, it may be skipped in the current render as there are already a sufficient number of training examples for it. Unrendered parts of an image can be tagged with a reserved pixel value acting as a mask value. Consequently training can be performed using input positons, direction information and a target value for unmasked pixel positions only. This can significantly reduce the redundancy within the training set, and also the associated computational load, both when ray tracing the training images and when training the NPLM.

Exceptions can optionally be applied. For example pixels near the centre of the image may always be rendered, as the central pixel typically relates to the position in the scene that was selected (or not culled), possibly as a function of its surface properties as described elsewhere herein—it is typically the pixels in the non-central parts of an image that are likely to capture unintended and unwanted repetitive points within the scene.

-   -   Training with variable lighting states

The various training techniques described previously herein are typically performed using a plurality of different ray-traced images of a scene, object, or material (herein generically referred to as a ‘scene’ unless specified otherwise), for a given lighting condition; typically it is assumed that the lighting sources are fixed within a scene (e.g. due to the position of windows, and/or due to the use of a so-called ‘sky dome’ providing a static illumination map).

However, in some circumstances the lighting of a scene may vary considerably; for example some games model a day/night cycle, and/or weather, and so the position of the sun (or moon) may change over the course of a virtual day (or night) within the game. Similarly depending on the weather the dominant light source may be a nearly point source such as the sun, or a diffuse source such as a back-lit cloud.

An NPLM trained to model the illuminance of a scene according to one lighting condition may not be able to generalise sufficiently well to replicate other conditions.

Accordingly, in an embodiment of the description, an NPLM is trained (using any of the techniques described herein) to model the illuminance of a scene based upon ground truth images that have been ray traced using multiple lighting conditions.

Typically these lighting conditions will comprise one or more adjustments of a lighting parameter within a predetermined range.

Lighting parameters can include:

-   -   Position: for example the progression of the sun over a         predetermined range. This may be achieved by rotating a sky dome         comprising the sun in various ray traced renders. Other examples         may include the movement paths of non-player characters or other         mobile light sources.     -   Direction: directional lights sources that change may be         modelled for a range of directional changes, e.g. in the case of         a lighthouse or an MPC/mobile light motion path. Alternatively         or in addition, the beam width or beam angle of spread of the         light may be specified (e.g. a torch or spotlight typically has         a narrower beam angle than a desk lamp).         -   Alternatively these or other less predictable light sources,             such as player-based mobile light sources like a torch or             similar could be implemented by using fully torch-lit and             non-torch-lit NPLMs for different parts of the scene             depending on where the torch light falls.     -   Colour or colour temperature: for example a progressive         reddening of the sun during a sunset.     -   Brightness.     -   Diffusion: for example replacing a rendered sky dome with         successive amounts of cloud or fog in front of a point light         source such as the sun or moon, or building lights etc.

A single NPLM may be trained on variations in one, two or more such parameters at once. For example, an NPLM may be trained on the sunrise, comprising a predetermined range of positions and also associated changes in colour temperature. Another NPLM may be trained on day time (or a part thereof) progression of the sun within a predetermined range of positions, without any change in colour temperature. A further NPLM may be trained on sunset, again comprising a predetermined range of positions and also associated changes in colour temperature.

As is noted elsewhere herein, a more complex training environment may require a change in NPLM architecture to accommodate network, typically up to a maximum when the memory footprint of the NPLM reaches a threshold size.

The NPLM may also require one or more additional inputs during training indicative of the parameter change or changes associated with the training data.

For example, lighting position may be explicitly input, and/or a proxy value such as time of day (for example if also correlated with colour temperature), or the like. Typically this could be input to the position network, to help characterise the relative position of scene elements with respect to the light, or could be input to the direction network, to help characterise the relationship between light source and viewpoint, or indeed input to both. The lighting position could relate to the position of a point light source, the centre of a diffuse light source, or the centre, or an offset position, for a skydome. The inputs could be rectilinear or polar, or any suitable format (e.g. polar may be more suitable for a skydome). Hence typical examples of changing positions would be along NPC paths (e.g. traffic), in-game movement of objects (e.g. a table lamp being moved) or environmental change (e.g. the sun or moon).

Similarly direction (and/or optionally beam angle of spread) could be input to one or both of the halves of the NPLM. Typical examples of directional change include a spotlight or sentry, or in combination with positional movement, traffic. Angle of spread values could be associated with these. Meanwhile an example of a change to the angle of spread includes opening a door that is in front of a light source.

Colour or colour temperature could be input for example as a scalar value (e.g. for colour temperature) or an RGB or similar colour representation. Typically the colour representation would be for the same colour space as the predicted image (i.e. the image pixels generated by combining the output of the NPLM with a particular BSDF, BRDF, BTDF or similar). Colour or colour temperature could be input to the position network, again to assist with classifying the scene positions embodied in the intermediate representation of the position network's output layer, and/or could be input to the direction network, as it may more easily influence the colour-related output of the NPLM there. As noted elsewhere herein, a typical example of a change in colour may relate to a rising or setting sun, but could also relate to a dramatic even, e.g. the activation of an alarm and associated switch to predominantly red lighting.

Brightness could be input as a scalar value in a similar manner to colour temperature to one or both halves of the NPLM. Again a typical example of a change in brightness can be associated with sunset or sunrise.

Diffusion of the light source, like direction, could be input to the position network to help with classification of the surface points, and/or could be input to the direction network to help with the relationship between the light source and the viewpoint. Examples of diffuse light sources may include cloud or fog, or urban/office environments with diffused ceiling lights.

It will also be appreciated that some or all of these parameters could be correlated with time, so that alternatively or in addition a time-based parameter is used. This was discussed above for position, but may also apply to colour, brightness or any of the other parameters. For example position, colour and brightness may all have a correlation with time when the scene is illuminated by the sun.

It will be appreciated that adding one or more such inputs to the existing first layer of one of the position and/or direction networks allows for only a single respective weight between the input and the nodes of the first layer in each network.

Hence, referring now also to FIG. 8B, optionally to provide the capability for a more complex learned response to these additional inputs, a further layer may be provided between the current first layer and two or more inputs to the respective halves of the NPLM. Hence for example rather than just providing the position of a light and the position of the current surface point as a parallel inputs to the existing NPLM position network, a further layer could be provided so that any significant combination of these values could be learned as a preparatory step.

Hence for example if in addition to the original surface point position input to the position network, all of the above inputs were included, a fully connected additional layer could be provided, or a partially connected layer, e.g. with directionality and diffusion input to a partial layer, brightness and colour to a parallel partial layer, and light position and surface point position to a parallel partial layer. These partial layers then fully connect to the first full layer of the network. A similar scheme could be used for the direction network.

FIG. 8B shows a partial layer for the original scene position and also the lighting position, and a parallel partial layer for the colour and brightness of the light, being included in the position network as a non-limiting example.

The training set for variable lighting conditions may simply comprise repeating any of the techniques described herein for generating a training set, for a plurality of lighting changes (e.g. for successive positions of the light(s)).

Alternatively, a single set of positions for full renders can be obtained as before, and then for each position a set of N versions are created by selecting either a random parameter value within a predetermined range, or a series of parameter values across that range, for each of the one or more parameters being varied. Optionally, where the probability approach is used to cull candidate positions, the probability of retention can either be made higher (to increase the number of selected positions, enriching the training set for a more demanding training situation) or the probability of retention can be made lower (up to N times lower) to mitigate the associated increase in computational load that comes from rendering variants for the same view. Whether the probability is increased, decreased, or remains the same reflects a trade-off between computational load and time on one hand, and eventual NPLM output quality on the other, for that particular illuminated scene.

Alternatively again, the probability of retention can be increased by up to N times, and for each resulting viewpoint just one (random or in-sequence) version of the parameter value is chosen so that rather than having multiple parameter values at one viewpoint, there are respective parameter values at multiple viewpoints.

It will be appreciated that the approaches overlap; for example generating training sets for a plurality of lighting changes, which can result in different respective constellations of viewpoints for each training set, may collective result in a set of different parameter values at the same positions and single parameter values at unique positions.

Typically there is no need to change how the distribution of viewpoints is generated, as this relates to the position of the viewer, not the light. However, for highly directional lights it may optionally be useful to bias the probability to retain a viewpoint as a function of the angular distance of the viewpoint from a reflection angle for the directional axis of the light (i.e. increase retention as the views get closer to being on a line of reflection into the light).

As noted previously herein, the NPLM can be implemented using any suitable machine learning system, and so whilst the split network architecture described herein is preferred, in principle an NPLM compising a single neural network (or indeed 3 or more networks or other machine learning systems, potentially of different types) may be used, with inputs as discussed herein being supplied to one or more of these as appropriate.

Variant Approaches

Each NPLM generates the learned quality for a single pixel in response to the scene surface position and viewpoint/mirror direction inputs described elsewhere herein, as well as any of the additional inputs also described previously herein.

Furthermore typically the contributions from several NPLMs (e.g. trained on diffuse, specular, translucent and other components of the scene) are combined when a final output is required.

As a result in principle contributions from several NPLMs could be combined from NPLMs each trained for respective lighting conditions. Hence for example an NPLM could be trained for the sun, or a skydome, set for 1 pm; and another could be trained for the sun/skydome at 2 pm. The contributions for the output for each one could then be combined, for example 100% of the 1 pm network at 1:00 pm, 75% of 1 pm and 25% of 2 pm at 1:15, 50/50 at 1:30, 25/75 at 1:45 and 100% of the 2 pm network at 2:00 μm.

For positional changes, optionally NPLMs for the specular contributions could be trained at finer intervals than NPLMs for the diffuse contribution, as the impact of the lighting change will be more obvious in the specular contribution. For example the specular NPLMs could be created for each hour interval or each 10% point along the parameter range, whilst the diffuse NPLMs are created for every two or three hours, or each 25% along the parameter range.

Hence the contributions from different NPLMs trained at different points on a parameter range can be blended to approximate the desired point on the parameter range, and the sampling of these parameter ranges by respective NPLMs can optionally be more sparse for less view dependent contributions such as the diffuse contribution, compared to the specular contribution.

It will also be appreciated that whilst the time example above is a 1-dimensional parameter, and so only requires blending two NPLMs trained with parameter values bracketing the desired parameter value, this approach can be extended to a two-dimensional parameter using 3 or more NPLMs (e.g. a triangle or other polygon in parameter space) whose weighted contributions correspond to a triangulation on the desired parameter value, or indeed a three dimensional parameter using 4 or more NPLMs (e.g. a tetrahedron or other volume in parameter space) whose weighted contributions again correspond to a triangulation on the desired parameter value.

It will be appreciated that this approach potentially requires an increased number of trained NPLMs to be used during the rendering of an image. These NPLMs may be pulled into GPU memory from a memory of the system in the same way as any other NPLM. Meanwhile they may be stored in the memory of the system in the same way as NPLMs described elsewhere herein, or an alternative NPLM streaming strategy may be used, as described elsewhere herein.

-   -   Training with variable object states

In a similar manner to training with variable lighting states as described above, an NPLM may be similarly trained where there is one or more dynamic objects within the scene.

Such a dynamic object may change position, orientation, pose/configuration, and/or indeed size, colour, and/or shape, for example for reasons relating to the nature of the object or for the purposes or gameplay or narrative.

Essentially a similar approach can be taken as with training with variable lighting states described elsewhere herein.

Hence an NPLM may again be trained (using any of the techniques described herein) to model the illuminance of a scene based upon ground truth images that have been ray traced using multiple object states representative of the variability of the object.

As noted above the variability may relate to position (for example a non-player character or an environmental hazard within the game may follow a known path within the environment).

Alternatively or in addition, it may relate to orientation (for example when an object spins or rotates on an axis, like a door). Often there is a correlation between position and orientation if an object faces in a varying direction of travel.

Alternatively or in addition, it may relate to pose/configuration; this may relate to a walking or other locomotion animation, or it may relate to character gestures or other animation cycles of an object.

Alternatively or in addition am object may vary its size, colour, or shape; in some games for example an opponent may transform during a battle. Similarly, a magical object may change its appearance in response to user interaction or in-game events.

As with the variable lighting states, a single NPLM may be trained on variations in one, two or more such parameters at once. For example, an NPLM may be trained on position, orientation and pose of an object as it is animated following a path within the environment.

Again as with the variable lighting states, a more complex training environment may require a change in NPLM architecture to accommodate network, typically up to a maximum when the memory footprint of the NPLM reaches a threshold size.

The NPLM may also require one or more additional inputs during training indicative of the parameter change or changes associated with the training data.

Again for example the object position may be explicitly input, and/or a proxy value such as a timing within an action loop of the object (i.e. having a correlation with the position in the training image) may be used. This could be input typically to the position and/or optionally the direction network (or to a single network, if used). A similar approach to the inputs for variable lighting states described elsewhere herein could also be used for position, pose, colour, size, and shape. Pose could for example be indicated by a proxy value such as a timing within an animation cycle (i.e. having a correlation with the pose in the training image), applied to the position and/or direction network.

It will also be appreciated from the above that some or all of these parameters could be correlated with time, so that alternatively or in addition a time-based parameter is used. This was discussed above for position and pose, but may also apply to orientation, colour, shape, size, or any of the other parameters. Notably different time references may be used for one or more different inputs; as non-limiting examples, position and orientation may use a time index corresponding to navigation of a path within the environment, whilst pose may use a time index corresponding to an individual step animation cycle.

Again as with the variable lighting states, where several object descriptive inputs are provided, optionally an extra layer may be provided to the NPLM as per FIG. 8B.

The training set for variable object states may simply comprise repeating any of the training techniques described herein for variable lighting conditions.

Again it will be appreciated that one approach is to blend the output of successive NPLMs that bracket a 1, 2 or 3 dimensional parameter space corresponding to one or more changes in object state, as described in relation to variable lighting states previously herein.

Network Configuration

As noted above, a position network (i.e. the first part of the split-architecture network described herein) may have a different number of outputs depending on whether it is trained for a diffuse of specular type image component. It will be appreciated that this is a specific instance of a more general approach.

In general, the capability of the NPLM may be varied according to the complexity of the modelling task it is required to do, either by increasing or reducing the capability from a notional default setup. In doing so, the architecture of the network is typically altered to change the capability.

In a first aspect, the capability may be varied based on the size of the NPLM (e.g. the number of layers, the size of layers and/or the distribution of layers between parts of the NPLM, thereby modifying the architecture of the NPLM to alter its capability).

Hence optionally the size can vary according to the type of contributing component the NPLM is modelling (e.g. diffuse, specular, or translucent/transmissive).

In particular, the size of the position network may be beneficially made larger for specular or translucent/transmissive components compared to diffuse components, all else being equal, due to the greater variability of lighting responses inherent in these components. For similar reasons, the size of the position network may be beneficially made larger for translucent/transmissive components compared to specular components, all else being equal, due to the combinations of partial reflection, transmission and internal reflection that may be involved.

Similarly, the size of the position network may be beneficially made larger in the case where changes to one or more lighting conditions are being trained (as not limiting examples, different lighting positions, directions, and/or angular widths), due to the increased number of lighting conditions, or the complexity thereof for a given scene surface positon, that need to be modelled.

The size may be varied by alteration to the number of hidden layers or the number of nodes within one or more such hidden layers. Similarly the size may be varied according to the number of output layers (for example the output layer of the position network, which is also a hidden or interface/intermediate layer between the position network and direction network of the overall NPLM network). An increase in the number of layers typically increases the spatial distortion that the network is capable of applying to the input data to classify or filter different types of information, whilst an increase in the number of nodes in a layer typically increases the number of specific conditions within the training set that the network can model, and hence improves fidelity. Meanwhile an increase in the number of output nodes (where these are not selected to map onto a specific format, as in the output of the position network) can improve the discrimination by the output network (and also by a subsequent network operating on the output node values) by implementing a less stringent dimension reduction upon the internal representation of the dataset.

Alternatively or in addition, the size of the direction network can vary according to the type of contributing component the NPLM is modelling (e.g. diffuse, specular, or translucent/transmissive).

As noted above, the input layer of the direction network can change in size to accommodate a higher dimensional output of the position network within the overall NPLM split-architecture network.

Similarly the number of layers and/or size of layers can be varied to similar effect as then outlined for the position network, i.e. increases in discriminatory capability and also model fidelity.

As with the position network, the size of the direction network may be beneficially made larger for specular or translucent/transmissive components compared to diffuse components, all else being equal, due to the greater variability of lighting responses inherent in these components. For similar reasons, the size of the direction network may be beneficially made larger for translucent/transmissive components compared to specular components, all else being equal, due to the combinations of partial reflection, transmission and internal reflection that may be involved. Hence like to position network, its architecture can be similarly altered to alter its capability.

Similarly again the size of the direction network may be beneficially made larger in the case where changes to one or more lighting conditions are being trained (as not limiting examples, different lighting positions, directions, and/or angular widths), due to the increased number of lighting conditions, or the complexity thereof for a given scene surface positon, that need to be modelled.

Hence the NPLM (e.g. the position network, the direction network, or both) may have its capabilities changed (e.g. changes to its/their architectures such as increased number of layers, internal nodes, or input or output dimensionalities), for example to improve discriminatory capabilities (for example due to more hidden layers or output dimensionality) and/or to improve model fidelity (for example due to more nodes in hidden layers), responsive to the demands of the lighting model required; with for example a diffuse contributing component typically being less demanding than a specular one.

Conversely, from a notional standard or default set-up for an NPLM, instead of increasing capability an NPLM may be beneficially altered to reduce its capability (e.g. by steps opposite those described above for increasing capability) where appropriate (e.g. for a diffuse component). In this case the benefit is typically in terms of reduced memory footprint and computational cost.

In addition to the type of reflection property (or properties) of a material as modelled by different contributing channels, alternatively or in addition the capability of an NPLM may be increased or decreased in response to other factors relating to the complexity of the lighting model/render process.

For example, a diffuse light source (such as a sky dome) may be less complex than a point light source, as there is less spatial/angular variability in the lighting the impinges on the object/scene. Conversely, a sky dome with significant spatial variability of its own (e.g. showing a sunset) might be more complex. The complexity of the light source may be evaluated based on its spatial and colour variability, for example based on an integral of a 2D Fourier transform of the lit space without the object/scene in it, typically with the DC component discounted; in this case a uniform sky dome would have a near-zero integral, whilst one or more point sources would have a larger integral, and a complex skydome (like a city scape or sunset) may have a yet larger integral. The capability of the NPLM (e.g. the size) could be set based on this or any such light source complexity analysis, for example based on an empirical analysis of performance.

Similarly, moving, dynamic or placeable lights may require increased NPLM complexity, as they create changing lighting conditions. In this case the input to the NPLM may comprise a lighting state input or inputs as well as the (x,y,z) object position for the specific part of the object/scene being rendered as for the output pixel. Hence for a model for a scene where the sun traverses the sky, an input relating to the time of day may be included, which will correlate with the sun's position. Other inputs to identify a current state of a light source may include an (x,y,z) position for one or more lights, an (r) radius or similar input for the light size, and/or and RGB input for a light's (dominant) colour, and the like. It will be appreciated that the training data (e.g. based on ray traced ground truths) will also incorporate examples of these changing conditions. More generally, where an NPLM it trained to model dynamic aspects of the environment, the training data will comprise a suitable representative number of examples.

In the case of the sun, the traversal for a whole day may need to be modelled by several NPLMs in succession (e.g. modelling dawn, morning, midday, afternoon and dusk), for example so to avoid the memory footprint or computational cost of the NPLM growing larger than a preferred maximum, as described elsewhere herein.

Similarly, moving, dynamic or placeable objects within the scene may require increased NPLM complexity if they are to be rendered using the NPLM (optionally the NPLM can be used to contribute to the render of static scene components only, and/or parts of the scene that are position independent). Hence again in this case the input may for example comprise object position and/or orientation data.

Alternatively or in addition, other factors may simplify the modelling of the NPLM and so allow the capabilities of the NPLM to be reduced (or for the fidelity of the model to be comparatively improved, all else being equal). For example, if the rendered scene comprises a fixed path (e.g. on a race track, within crash barriers), then training from viewpoints inaccessible by the user can be reduced or avoided altogether. Similarly if the rendered scene comprises limited or preferred viewing directions (e.g. again on a race track where most viewing is done in the driving direction), then training for different viewpoints can reflect the proportional importance of those viewpoints to the final use case.

Similarly, where parts of a scene may be viewed less critically by the user because they are background or distant from a focal point of the game (either in terms of foveated rendering or in terms of a point of interest such as a main character), then the NPLM may be made comparatively less capable. For example, different NPLMs may be trained for different draw distances to an object or texture, with capability (e.g. size) reducing at different draw distances/level of detail (LOD).

Alternatively or in addition, as noted elsewhere herein an NPLM can be trained for a specific scene, object, material, or texture. Consequently the capability of the NPLM can be varied according to the complexity of the thing whose illuminance it represents. A large or complex scene may require a larger NPLM (and/or multiple NPLMs handling respective parts, depending on the size of the scene and resultant NPLMs). Similarly a complex object (like a car) may benefit from a more capable NPLM than a simple object (like a sphere). One way of evaluating the complexity of the scene or object is to count the number of polygons, with more polygons inferring a more complex scene. As a refinement, the variance of inter-polygon plane angles can also be used to infer complexity; for example a sphere having the same number of polygons as the car model in the figures would have a very low angular variance compared to the car itself, indicating that the car is structurally more complex. Combining both polygon numbers and angular variance/distribution would provide a good proxy for the complexity of the scene/object for which illuminance is being modelled by the NPLM.

Similarly a complex material (like skin or fur) may benefit from a more capable NPLM than a simple material (like metal) (and/or multiple NPLM contributors). Yet again a complex texture (e.g. with a broad spatial spectrum) may benefit from a more capable NPLM than a texture with a narrower or more condensed spatial spectrum.

Whilst capability has been referred to in terms of size (number of inputs/outputs, number of layers, number of nodes etc), alternatively or in addition capability can be varied by the choice of activation function between nodes on different layers of the NPLM. As noted elsewhere herein, a preferred activation function of the position network is a ReLU function whilst a preferred and activation function of the direction network is a sin function, but other functions may be chosen to model other scenarios.

The capability of an NPLM may be made subject to an upper bound, for example when the memory footprint of the NPLM reaches a threshold size. That threshold size may be equal to an operating unit size of memory, such as a memory page or a partial or multiple group of memory pages, typically as selected for the purpose of accessing and loading textures for a scene/object/material. The threshold size may be equal to a texture or mipmap size used by the GPU and/or game for loading graphical image data into the GPU.

If the complexity of the NPLM would exceed this threshold, then the task it models may either have to be simplified, or shared between NPLMs, or the accuracy of the result may have to be accepted as being less.

Hence in summary, an image rendering method (focusing on network configuration and selection) may comprise a step of selecting at least a first trained machine learning model from among a plurality of machine learning models, the machine learning model having been trained to generate data contributing to a render of at least a part of an image, as discussed elsewhere herein. Hence for example the contributing data may relate to a particular component of an image pixel (e.g. for a diffuse or specular contributing component), or may relate to a complete RGB pixel (e.g. modelling all reflection aspects at once), for example depending on the complexity of the lighting and/or material, texture and/or other surface properties being modelled.

In such a method, the at least first trained machine learning model has an architecture-based learning capability that is responsive to at least a first aspect of a virtual environment for which it is trained to generate the data, as discussed elsewhere herein. Hence for example, the architectural aspect relating to learning capability may be in the size of all or part of the NPLM, such as the number of layers or nodes, and/or may relate to the nature of the connections between nodes of different layers (for example in terms of the degree of connectivity of the type of activations functions used).

In such a method, a second step may comprise using the at least first trained machine learning model to generate data contributing to a render of at least a part of an image. As discussed elsewhere herein. Hence for example an individual run of the NPLM may generate data that is used with data from other NPLMs to generate RGB values for a pixel of the image, or may generate data to generate RGB values for a pixel of the image by itself, for example after subsequent processing (e.g. combining with a distribution function) as described elsewhere herein.

Network Selection

The networks are trained during a game or application development phase. The developer may choose when or where NPLM based rendering would be advantageous. For example, it may only be used for scenes that are consistently found to cause a framerate below a predetermined quality threshold. In such cases, the networks are trained on those scenes or parts thereof, and used when those scenes are encountered.

In other cases, the developer may choose to use NPLM based rendering for certain objects or certain materials. In this case, the networks are trained for and used when those objects or materials are identified as within the scene to be rendered.

In other cases, the developer may choose to use NPLM based rendering for certain lighting conditions or combinations thereof. In this case, the networks are trained for and used when those conditions are identified as within the scene to be rendered. A similar approach may be used for dynamic objects, as described elsewhere herein.

Similarly, the developer may choose to use NPLM based rendering for particular draw distances (z-distance), or angles/distance away from an image centre or user's foveal view, or for certain lighting conditions. In this case, the networks are trained for and used in those circumstances.

Similarly, it will be appreciate that any suitable combination of these criteria may be chosen for training and use.

Meanwhile as noted above, during use of the system there may be a plurality of NPLMs associated with a scene, for a plurality of reasons. For example, plural NPLMs may exist to model a large scene (so that each part is modelled sufficiently well by an NPLM within a threshold size and/or to a threshold quality of image reproduction). Similarly plural NPLMs may exist due to varying lighting conditions, levels of detail/draw distance, and the like.

The appropriate NPLM(s) for the circumstances may be selected and retrieved to GPU accessible working memory and run for the purpose of rendering at least part of an image. It will be appreciated that strategies applied to prefetching and caching textures and other graphical assets can also be applied to NPLMs.

Network Streaming

As noted elsewhere herein, a relevant NPLM or NPLMs may be selected due to the contribution it or they make to an image pixel (e.g. diffuse, specular or the like), and/or due to what they model; for example a location within the environment, or a particular scene, object, or material, and/or a range of states for variable lighting or one or more dynamic objects, or a particular state of a variable light or dynamic object(s).

In some cases the outputs of several NPLMs may be merged (for example in a weighted fashion) as described elsewhere herein in relation to variable lighting or object states, or also potentially for boundaries between locations or scenes.

In any event it will be appreciated that there may therefore be a large number of NPLMs to select from, dependent upon the current overall game or application state (for example dependent upon location, scene (which for example may in turn be viewpoint or game event dependent at a location), object or material (which again may be location, scene, or event dependent, and/or a property of a dynamic object), and/or lighting (which again may be location, scene, or event dependent, and/or a property of a variable light), and or any proxy for one or more of these, such as time.

Selection of such NPLMs may be limited to selecting NPLMs found in local storage at runtime (e.g. in system/CPU ram, flash memory hard disk or solid state disk, optical disk and the like); i.e. NPLMs provided with other assets of a given game or application for the purpose of rendering it.

However it will be appreciated that whilst individual NPLMs require relatively little memory to store, a client device such as a videogame console is a resource constrained system, and so a profusion of NPLMs that cover a potentially very large number of permutations of circumstances for rendering a game may place an undue burden on the console. For example, by making installation of a videogame larger (due to these NPLMs), a console may be able to store fewer games overall, and the process of installing a game (and potentially loading it when selected) are also likely to take longer.

Hence, alternatively or in addition, NPLMs may be streamed from a server as required.

For example, a user may be traversing a particular environment whose rendering is supported by the techniques herein. Accordingly, NPLMs may have been created for a number of different times of day and night, and for different weather conditions, four successive portions of the environment.

Supposing, as non-limiting examples, that for each of 10 environment portions (representing distinct parts of the environment being traversed) there are 10 time periods (covering different sun and moon positions) and four weather conditions (as non-limiting examples: clear, resulting in a point light source; light cloud, resulting in a semi-diffuse light source; heavy cloud, resulting in a diffuse light source; and mist, resulting in modified reflections).

As a result in total there are potentially 400 NPLMs required to traverse this particular environment under all circumstances, but only one (or one per contributing component) is required at any given time. Furthermore, in this case the next one to be required can be anticipated by the user's direction of travel and the passage of time (and weather), and the ability to predict one or a small number of candidate NPLMs to use next will generally be the case within any game or application using them.

Consequently it is far more memory efficient to download the required and/or anticipated NPLMs from a central repository (or peer/distributed repository) than to store all potentially required NPLMs locally.

Accordingly, the entertainment device/videogame console/client device is adapted to transmit game state data to a remote server that stores NPLMs for the game/application (or points to where they are stored in a peer or distributed system). The game state data transmitted for a given game/application is chosen to be relevant to the selection of NPLMs. For example if the game does not model the passage of time in the form of sun or moon transit, then this may not be a relevant measure. Similarly if the game does not model differences in weather then this may not be a relevant measure.

Typically however the game state data will comprise an indication of the scene to be rendered or anticipated to be rendered, whether this is described by a set of coordinates specifying a position within the virtual world (and optionally also a viewpoint direction of the virtual camera), or a unique number associated with a scene.

Hence returning to the above example, if the user is currently in the fifth of ten environment portions, and traversing toward the sixth during a clear dawn within the game, then the entertainment device can transmit a request for an NPLM corresponding to the 6^(th) environment portion, with dawn lighting in clear weather. The format of the request may be any suitable format, for example using a co-ordinate scheme, tiling number scheme, or other scheme for the environment portions, and time or lighting variant types to indicate dawn, and weather variant types too.

Optionally, if the format is consistent, it may be used to define at least part of a requested NPLM filename and/or URL, thereby simplifying the process for the server (which may handle many millions of requests). Hence for example the request may be to receive file 0006-06-01.npm, being the NPLM for the 0006^(th) environment portion, for 06:00 (dawn) in weather type 01 (clear), or similarly to download http://www.gamename.com/0006/06/01/file.npm.

For cases where the correct NPLM is less clear (for example if the user is navigating towards a region bounded by several other environment portions) then the client entertainment device can request several NPLMs for different outcomes, for example requested in order of probability or urgency (e.g. based on proximity to the respective environment portions). It will be appreciated that a state of the application may anticipated if a boundary of that state is within a threshold of the current state of the application, and that a given state can have multiple boundaries (for example boundaries of time, location, lighting condition and dynamic object properties).

Hence in the above example for file 0006-06-01.npm, the associated game state may become an anticipated game state any in-game time after 05:45, or at any location within 100 in-game metres of environment portion 6, or when the weather is scheduled to transition to clear. In this case the thresholds are, for example, 15 minutes, 100 metres and a weather transition (towards clear), respectively.

For games or applications that have emergent scenes (e.g. procedurally generated), or just with large numbers of permutations of circumstance, the game state data, being descriptive of the current (or typically upcoming/expected) scene, may describe a situation for which an NPLM has not yet been created.

In this case, the NPLM associated with a game state closest to the transmitted game state can be duplicated and treated as a partially trained NPLM. This NPLM may then be trained on the new scene, either at the server (if the client entertainment device uploads images rendered by other means, such as ray tracing, as discussed elsewhere herein in relation to failure modes), or at the client entertainment device, either during game play for successive images rendered by other means, or after game play is over (for example as a background task, using a recording of the rendered images within a circular image buffer, or saved from such a buffer to storage for this purpose). The device could also have a background training mode, with the game or application rendering (but not necessarily displaying) images of scenes for NPLM training as described elsewhere herein, for example as a background task. Hence for example a list of game states could be accumulated during play, and then re-rendered (not necessarily at a playable frame rate) for training purposes, for example when the device was in a sleep mode.

In any case the newly trained NPLM(s) can then be stored by the server (or peer or distributed storage) in association with the game state data, so that the next time that game state is encountered an NPLM is available.

In this way, very quickly new NPLMs will be trained that fill in any unanticipated gaps within the existing suite of NPLMs. Typically this process may occur during QA testing or alpha or beta releases of a game, but can also be used when a game is released to conventional users.

This may be beneficial not just because a large number of users may result in yet further game states being encountered, but because many games allow for users to create their own content; in these circumstances NPLMs for example already trained on materials and objects selectable by users in a creative mode may be cloned and used to generate NPLMs for their new scenes and environments. Alternatively entirely new NPLMs can be trained on images from these creations, either at the server or client device, and either at runtime or subsequently (for example, based on a seed NPLM). It will be appreciated that at runtime, the training may result in additional computational overheads, and so in some cases it may be preferable to use the recorded images when the game or application is no longer requiring most of the devices computational resources (e.g. after the game or application has been stopped).

It will be appreciated that, as discussed elsewhere herein in relation to specific example of variable lights and dynamic objects, the outputs from NPLMs for adjacent game states could be blended when at or near the boundary of such game states. Typically the relative contribution of each NPLM would be a function of the proximity of the boundary between game state, whether than boundary is a location, a time, or (as per the previous examples) a state of light or a property of a particular object. This approach provides a smooth transition between NPLMs for different game states, and may avoid noticeable changes in rendering behaviour between successive NPLMs, if it exists.

It will be appreciated that the above discussions for streaming, training, and/or blending NPLMs also apply where in practice the NPLM actually refers to several contributing NPLMs, for example for diffuse and specular image components.

Hence where a corresponding NPLM is available to download/stream the above technique results in a form of just-in-time delivery of relevant NPLMs for use during the rendering of scenes, thereby removing the overhead associated with storing a plurality of NPLMs for a plurality of circumstances that any one player of the game is unlikely to encounter. Meanwhile where the corresponding NPLM is not available or the download is too slow, the system can fail over to an alternative rendering technique (see below) and/or train a new NPLM (for example seeded from a closely corresponding NPLM) based on images for the game state that is missing a corresponding NPLM. This can be done during runtime if resources permit, or afterwards using a recording of footage generate in that game state if resources otherwise do not permit, or at the server. The newly trained NPLM is then available when that same game state is subsequently encountered by the same or any other user.

Failure Modes

The NPLMs as described herein generate values that, when combined with a respective distribution function and typically then also in combination with contributions from other NPLMs (e.g. for diffuse and specular components), generate a pixel value for an image that is a computationally efficient approximation of a ray traced pixel value for that image.

Hence in general it is preferable to use one or more NPLMs to render the scene/object/material as appropriate, as long as this remains computationally efficient, and the resulting approximation is good enough.

However, there can be cases where one or both of these conditions are not met.

In particular, the distribution functions (BSDF, BRDF and BTDF) described herein typically assume a non-zero amount of light scattering, with specular scattering being more direction dependent than diffuse scattering (which can be assumed to be a perfect or uniform scatter).

Furthermore, this scatter serves to visually conceal, within the collective pixel results of successive runs of the NPLMs, approximation errors within the model, so that particularly for diffuse contributions, but also for specular contributions, there is an elevated error tolerance due to the nature of the materials being modelled.

However, for mirror-like surfaces (which can also include glass, which is typically an 8% mirror and 92% transmitter), these have little or no scatter; as a result errors within the resulting image are more apparent, both to the user and also in terms of the error values generated during training, in turn making training more difficult.

As noted elsewhere herein, optionally NPLMs can be made larger to model more difficult lighting conditions, for example by using a larger NPLM for specular contributions than diffuse contributions to the same scene. This principle extends to potentially using a larger NPLM for mirror-like reflective surfaces, in order to provide the resources required to adequately model the lighting response.

Hence for a given NPLM that may be adequate for diffuse or specular contributions, it may be that it does not comprise sufficient resources to adequately model the lighting conditions for a mirror-like reflective surface to an acceptable level of accuracy; meanwhile a sufficiently large NPLM may take a long time to train to the desired accuracy, and also use more memory and computational resources at runtime.

Hence depending on the preferred maximum size and computational limits of the NPLMs used, there is a point on a line between a purely diffuse surface and a purely reflective surface at which the specular scattering becomes small enough (e.g. narrow enough or directional enough) that the approximation provided by the NPLM may no longer be good enough.

Similarly, depending on the desired accuracy of the approximation, there is also a point on the same line where the NPLM needed to achieve that accuracy exceeds a maximum budget for memory or computational load, if such a budget exists.

Meanwhile, by contrast, mirror-like surfaces are relatively straightforward to render using ray tracing precisely because there is little or no scattering. As a result ray traced rendering of mirror-like surfaces can have a relatively low computational cost compared to other ray tracing.

Hence for a threshold degree of reflectivity at a scene surface position (with a perfect mirror being at one extreme and hence typically above the threshold), it may be preferable not use NPLMs to generate pixels for that position, but instead use ray tracing (or optionally another rendering technique such as existing non-ray-traced rendering methods). As noted above the reason could be due to insufficient accuracy of the NPLM, relative computational cost of the NPLM(s), or a mixture of both.

Above this threshold, it may therefore be preferable to use ray tracing for the corresponding pixel, or any other suitable approximate approach, as an alternative or ‘failure mode’.

Referring back to the example car in FIG. 2, the virtual chrome on the front grille of the car is more mirror-like than the body, which in turn is more reflective than the wheels or wheel rims, or the seat.

Hence for the purposes of explanation, we can state as an example that the chrome on the front grille of the car is sufficiently reflective that an NPLM modelling that material either does not meet an accuracy criterion set by a developer, or to meet that accuracy criterion does not meet a memory or computation budget, and hence the chrome radiator is a candidate for failing over to conventional ray tracing or some other alternative approach.

It will be appreciated that typically the degree of reflectivity will be consistent for a given material in a scene—in this case the chrome. As a result a first option is to use a material ID or a value associated with such an ID to indicate whether to use an NPLM or an alternative technique such as ray-tracing for any pixel corresponding to that material.

This material ID can be the same as the material ID discussed elsewhere herein with which a value was associated indicating how diffuse or specular the material surface is. In that example, a notional range between 0 for completely diffuse and 1 for a mirror reflection was suggested. Hence in this case any material ID with an associated value above a predetermined threshold of, as a non-limiting example, 0.95 could be considered a candidate for this fail-over approach. In this case if NPLMs are trained on a per-material basis, then optionally an NPLM may not be trained for this material at all. Alternatively when an NPLM is trained on an object or scene comprising multiple materials (as in the example car), then the material ID and value associated with a surface position can be looked up to decide whether to use the NPLM or an alternative technique; hence in this case the NPLM would get used for everything except the chrome grille, and possibly the steering wheel.

It will be appreciated that rather than having an associated value, a flag could be incorporated into the material ID; for example a lowest or highest significant bit (or any predetermined bit) could be used within an ID number to signify that the material should or should not use an NPLM, and hence whether to fail over to an alternate rendering approach.

Whilst a material ID has been described, it will be appreciated that other corresponding IDs may be consistently associated with a particular surface position, such as a cluster ID or object ID, or an ID specific to use or non-use of machine learning systems such as NPLMs for rendering. Hence alternatively or in addition optionally a reflection value or flag may be associated with such an alternative ID.

It will be appreciated however that some techniques described herein do not require a material or other corresponding ID, and hence some implementations may not use (or may not wish to use) such IDs.

Hence alternatively or in addition, other mechanisms for determining whether a surface position in the scene should be rendered using NPLMs or an alternative can be considered.

Firstly, the distribution function associated with a surface position (e.g. the BSDF, BRDF, BTDF or other distribution function) can be considered indicative of how mirror-like the surface position is. Consequently a distribution function indicating a threshold degree of mirror-like reflectance, or associated with an element of the scene having such a threshold degree of mirror-like reflectance, can be identified as indicative that the surface position should not be rendered with an NPLM but instead with another technique.

Similarly, the convergence rate of an NPLM and/or its eventual loss/error function performance when being trained may be taken as an indication of the accuracy of the result; if the error or loss function for the output of a given NPLM associated with a given surface position takes more than a threshold number of training cycles to converge on a threshold value, or alternatively or in addition if (optionally despite an overall threshold value for the entire scene being reached) the error or loss function for a given surface position never reaches of falls below a threshold value, then this indicates that the NPLM should not be used for that surface position.

Hence based on the training behaviour of an N PLM, certain surface positions (or materials with a material ID associated with that surface position) would not be rendered by NPLM but instead using an alternative technique. In this case a flag or value could be embedded or associated with a material ID, the associated distribution function, or a value characterising the surface or its position, as appropriate.

Meanwhile, alternatively or in addition a sample sub-set of pixels in an image or part thereof may be test-rendered using multiple techniques. For example between 0.1%, 1% or 10% of pixels in an image may be rendered using ray tracing and using one or more NPLMs. The sample may be random, or, to simplify tracking, a regular pattern (e.g. one pixel in every 3×3, 4×4, 8×8 or 16×16 square).

The computational load of the candidate techniques could be compared; if the NPLM uses fewer resources, it may be selected for the rest of the image or the part thereof being evaluated (the part may correspond to an arbitrary or preselected text portion of the image, or an object or material within the image).

Similarly the accuracy of the candidate techniques could be compared; assuming that the ray-trace is accurate, then if the NPLM result is within a threshold difference of the ray traced version it may be considered acceptable (typically also in conjunction with confirmation that it uses fewer computational resources).

In either case, one of the sample pixels tested can then contribute to the final image; typically the sample pixel generated using the selected technique, so as to be consistent with its neighbours. Hence for example even if a ray-traced pixel is more accurate, if NPLM has been chosen then the NPLM pixel may be used.

The remaining pixels may then be rendered using the chosen approach.

It will be appreciated that the above techniques can optionally be combined as suitable. Hence for example a material ID or associated value, or a distribution function, may be used to determine what pixels or areas of the image to sample for a test between an NPLM and an alternative technique. Conversely such tests, for example during development rather than at runtime for an end-user, or the training behaviour of an NPLM, may be used to identify materials or distribution functions for which it is preferable not to use an NPLM.

Hence by use of any suitable combination of the above techniques, all or part of a given image may fail over from using one or more NPLMs to an alternative rendering technique such as ray tracing, when the accuracy of the NPLM(s) other their computational or memory costs mean it is preferable to do so, optionally signalled by values or flags associated with a material ID or distribution function for a given surface position, and/or in response to test renders of a subset of pixels.

As a separate consideration to the failure modes discussed above, alternatively or in addition another failure mode may be considered as follows.

As noted previously herein, an NPLM may be trained for variable object states and variable lighting states.

In such circumstances, in addition to outputting the learned quantity as described elsewhere herein, the NPLM can also output a confidence metric. This confidence metric indicates the degree to which the object's current state, and/or the lighting's current state, as appropriate can be adequately modelled by the NPLM.

The confidence in the model may dip for a variety of reasons. Firstly, the NPLM may be constrained, either in terms of size (e.g. either a practical maximum size has been reached, or a size has been selected for other reasons), or in terms of training (for example due to a large number of permutations of both camera position and object state and/or lighting state); and as a result of the constraint(s), the output of the NPLM may not be adequate in some circumstances.

Secondly, the object state may be unpredictable; for example whilst an object may move along a predetermined path for which training images can be generated, the game may require the object to divert from that path if the user stands in it, or placed an object in the path as part of the game. This may result in changes in local lighting conditions that have not been specifically provided during training. Whilst the NPLM, like other machine learning systems, can typically generalise outside its direct training examples, the more the new scene diverges from experience the less acceptable the results might be. Similarly a lighting state may be interactive, for example when a door is opened into a lit environment, or when an object is a light source itself.

The confidence metric output by the NPLM (for example, a fourth output node of the NPLM to accompany the three RGB values of the learned quantity) can be trained by comparing the current learned output of the NPLM during training with the training target; the difference, if any, between these values is the effective error or cost function. For the output RGB values, the corrections for improving these values will be fed back to the NPLM for the respective outputs.

In parallel, a value indicative of the acceptability or confidence of those outputs can be provided as a target value for the confidence metric output of the NPLM (e.g. the fourth output value). This trains the NPLM to provide an estimate of its own accuracy/acceptability/confidence in its outputs.

The nature of the accuracy/acceptability/confidence depends upon how the error or cost function is represented by this fourth target value. For example, the value could saturate at 1 for errors above a first threshold (e.g. the threshold of minimum acceptability), and progress down to 0, either linearly or non-linearly, for errors at or below a second threshold (including down to a threshold of zero), so that the value only gave an accuracy, acceptability, or confidence score below 1 for outputs that were already close to accurate or acceptable (where close is defined by the first threshold). This gives good discriminatory capabilities to the NPLM rather than trying to model a whole range of possible errors within the output. It will be appreciated that ‘1’ and ‘0’ above are purely illustrative values.

In an alternative example, the value could be binary, with ‘1’ as acceptable and ‘0’ as unacceptable, again based on a threshold set by the trainer. The NPLM will then model an internal representation of the acceptability threshold. The binary value could be a hard binary (e.g. a Heaviside function) or a soft binary (e.g. a sigmoidal or ramp function).

The value could be based on the error in just the current contributing values (i.e. the vales currently output by the NPLM), or may comprise a component reflecting the overall or average error fora number of values (e.g. for values within a threshold distance of the current surface position in the scene, or values for the image as a whole). The value could alternatively or in addition comprise a component that is a moving average of N prior current values. Each of these optional additional components provide the NPLM with information about its more general performance at the task for the current image.

The threshold for acceptability (or minimum acceptability) may be set by the trainer of the NPLM (e.g. the developer) and/or may be a default or pre-set threshold.

Using this confidence metric, the NPLM can thus learn to estimate the accuracy (or acceptability) of its own output when an error value is not available, e.g. at runtime.

Accordingly, when the output of the NPLM confidence metric does not reach a predetermined value (e.g. a threshold value, which may be different from the acceptability or minimum acceptability threshold values above), this can indicate the NPLM's own assessment that its output is not acceptable for use.

In this case, the system can then fail over to an alternative rendering scheme such as ray tracing or a more conventional rendering technique, for the particular pixel to which the NPLM is contributing values.

In the case where the NPLM indicates a low confidence (or equivalently poor accuracy or acceptability), this means that the NPLM has already performed the processing necessary to generate the learned quantity for its contribution to the current pixel; consequently in this case it is becomes a net overhead to the eventual rendering of the pixel by other means.

Hence if an object in the scene has entered a state that the NPLM estimates it will have difficulty with, or similarly a lighting condition has entered a state that the NPLM estimates it will have difficulty with, it is likely that a significant proportion of NPLM outputs will have a low confidence/accuracy/acceptability rating.

Consequently, optionally where an NPLM generates a threshold number of low confidence/accuracy/acceptability estimates, it is no longer used and the system fails over to an alternative rendering scheme.

This approach may be applied for the whole of a material, or the whole of an object, or the whole of a scene.

It will also be appreciated that where a given pixel is generated based on the contributions of several NPLMs, it may only require one NPLM to generate a low confidence/accuracy/acceptability value to have that pixel replaced with an alternative render, and similarly optionally only one NPLM to generate a threshold number of such values to have the system fail over to the alternative rendering scheme.

To facilitate this approach, an NPLM may be used to render an image starting with test renders; for example on a regular distribution (e.g. one in 8×8 or one in 16×16 pixels) within an image, or for a specific object or material in the rendered scene. If the NPLM generates a threshold number of low confidence/accuracy/acceptability estimates (e.g. values not satisfying a threshold value) during these test renders, it may be suspended for that image, object, or material as appropriate, and then test again for the next image, object, or material. In the latter cases, the subsequent object or material may be in the same rendered image.

In this way it is possible to quickly and efficiently detect when an NPLM evaluates itself to be producing unacceptable results, and replace the NPLM with an alternative rendering scheme for the relevant pixel, material, or object within a rendered image, or the entire rendered scene in a rendered image, as desired.

As noted above the alternative rendering scheme may be ray tracing or a conventional rendering process, but alternatively it may be a different NPLM; for example when objects move in a complex path, two or more NPLMs may be trained on respective parts of the path, typically with some overlap of the path between them, and so when the confidence metric of a current NPLM starts to indicate a confidence below a handover threshold value, that NPLM can we swapped out for another that has been trained on the new object positions.

As noted above a failure mode of the types described herein may also be invoked when a downloaded or streamed NPLM is not available (or is not received in time for use). Such a failure mode may also trigger a training step, and/or mark part of a buffered video stream for use in subsequent training.

Such a failure mode may also trigger a change to the definition of ‘anticipated game state’, for example causing not merely an adjacent game state to be downloaded, but also game states at one or more remove, to account for possible download delays. Hence for example if a user appears to be traversing from environment portion 5 to environment portion 6, the failure mode may also request download of one or more NPLMs for environment portion 7.

SUMMARY

Referring now to FIG. 9, in a summary embodiment of the description, an image rendering method for rendering a pixel at a viewpoint comprises the following steps, for a first element of a virtual scene having a predetermined surface at a position within that scene.

In a first step s910, provide the position and a direction based on the viewpoint to a machine learning system previously trained to predict a factor that, when combined with a distribution function that characterises an interaction of light with the predetermined surface, generates a pixel value corresponding to the first element of the virtual scene as illuminated at the position, as described elsewhere herein.

In a second step s920, combine the predicted factor from the machine learning system with the distribution function to generate the pixel value corresponding to the illuminated first element of the virtual scene at the position, as described elsewhere herein.

And, in a third step s930, incorporate the pixel value into a rendered image for display, as described elsewhere herein. The image may then be subsequently output to a display via an A/V port (90).

It will be apparent to a person skilled in the art that one or more variations in the above method corresponding to operation of the various embodiments of the method and/or apparatus as described and claimed herein are considered within the scope of the present disclosure, including but not limited to that:

-   -   a respective machine learning system is trained for each of a         plurality of contributing components of the image (e.g. diffuse,         specular, coat, etc), a respective distribution function is used         for each of the plurality of contributing components of the         image, and the respective generated pixel values are combined to         create the pixel value incorporated into the rendered image for         display, as described elsewhere herein;     -   the respective distribution function is one or more selected         from the list consisting of a bidirectional scattering         distribution function, a bidirectional reflectance distribution         function, and a bidirectional transmittance distribution         function, as described elsewhere herein;     -   the machine learning system is a neural network, an input to a         first portion of the neural network comprises the position, and         an input the a second portion of the neural network comprises         the output of the first portion and the direction, as described         elsewhere herein;         -   in this instance, an activation function of the first             portion is different to an activation function of the second             portion, as described elsewhere herein;             -   in this case, the activation function of the first                 portion is a ReLU function and the activation function                 of the second portion is a sin function, as described                 elsewhere herein;         -   in this instance, the cost function of the neural network is             based on a difference between the output of the second             portion and a value derived from a ray-traced version of the             pixel for a training image on which an inverse combination             with the distribution function has been performed, as             described elsewhere herein;         -   in this instance, the cost function for the network is             back-propagated though both the second and first portions             during training, as described elsewhere herein;         -   in this instance, the neural network is a fully connected             network, as described elsewhere herein;     -   the cost function of the machine learning system is based on a         difference between the output of the machine learning system and         a value derived from a ray-traced version of the pixel for a         training image on which an inverse combination with the         distribution function has been performed, as described elsewhere         herein; and     -   the machine learning system is selected and loaded into a memory         used by a graphics processing unit based on the same asset         identification scheme used for selecting and loading a texture         for the first element of the scene.

Next, referring to FIG. 10, in another summary embodiment of the description, an image rendering method for an entertainment device (focusing on downloading/streaming NPLMs to save on local storage and/or memory management) for rendering a pixel at a viewpoint, comprises the following steps.

For a first element of a virtual scene, having a predetermined surface at a position within that scene, a first step s1010 comprises obtaining a machine learning system previously trained to predict a factor that, when combined with a distribution function that characterises an interaction of light with the predetermined surface, generates a pixel value corresponding to the first element of the virtual scene as illuminated at the position, as described elsewhere herein.

This step in turn comprises several sub-steps.

In a first sub-step s1012, the obtaining step comprises identifying a current or anticipated state of an application determining the virtual scene to be rendered, as described elsewhere herein.

In a second sub-step s1014, the obtaining step comprises requesting a download of a machine learning system corresponding to the current or anticipated state, from among a plurality of machine learning systems corresponding to a plurality of states of the application, accessible via a remote server (e.g. either downloaded from the server or pointed to by the server), as described elsewhere herein.

In a third sub-step s1016, the obtaining step comprises downloading the requested machine learning system (e.g. via the remote server), as described elsewhere herein.

A second step s1020 then comprises providing the position and a direction based on the viewpoint to the machine learning system, as described elsewhere herein.

A third step s1030 then comprises combining the predicted factor from the machine learning system with the distribution function to generate the pixel value corresponding to the illuminated first element of the virtual scene at the position, as described elsewhere herein.

Then a fourth step s1040 comprises incorporating the pixel value into a rendered image for display, as described elsewhere herein.

Again it will be apparent to a person skilled in the art that one or more variations in the above method corresponding to operation of the various embodiments of the method and/or apparatus as described and claimed herein are considered within the scope of the present disclosure, including but not limited to that:

-   -   the current or anticipated state of the application comprises a         virtual location, as described elsewhere herein;     -   the current or anticipated state of the application comprises         one or more selected from the list consisting of a notional time         within the virtual scene, a lighting condition, and a state of a         dynamic object, as described elsewhere herein;     -   the requesting step comprises formulating a file name or file         location of the machine learning system based upon the current         or anticipated state of the application, as described elsewhere         herein;     -   the requesting step comprises requesting a plurality of machine         learning systems respectively corresponding to a plurality of         anticipated states of the application, as described elsewhere         herein;     -   a state of the application is treated as anticipated if the         current application state is within a threshold of a boundary         with that state, as described elsewhere herein;     -   responsive to the proximity of the current application state to         a boundary between two or more application states, the outputs         of the corresponding two or more machine learning systems are         blended, as described elsewhere herein;     -   if upon request no machine learning system corresponds to the         current or anticipated state, the method comprises selecting a         machine learning system closely corresponding to the current or         anticipated state, and training a copy of the selected machine         learning system on image data corresponding to the current or         anticipated state, as described elsewhere herein;         -   in this case, optionally the step of training comprises             uploading image data from the entertainment device to the             remote server, training the copy of the selected machine             learning system at the remote server, and associating the             trained copy with the current or anticipated state, as             described elsewhere herein;         -   alternatively in this case, optionally the step of training             comprises downloading the copy of the selected machine             learning system from the remote server, training the copy of             the selected machine learning system at the entertainment             device, uploading the trained copy from the entertainment             device to the remote server, and associating the trained             copy with the current or anticipated state, as described             elsewhere herein;             -   in this latter instance, optionally the training is                 performed during operation of the application based on                 image data rendered by the application using an                 alternative rendering method, as described elsewhere                 herein;             -   similarly in this latter instance, optionally the                 training is performed separately to the operation of the                 application based on image data obtained from an image                 buffer used to record video clips of rendered image                 data, as described elsewhere herein; and     -   the step of incorporating the pixel value into a rendered image         for display comprises using respective machine learning systems         that have each been trained for one of a plurality of         contributing components of the image, using a respective         distribution function for each of the plurality of contributing         components of the image, and combining the respective generated         pixel values to create a final combined pixel value incorporated         into the rendered image for display, as described elsewhere         herein.

It will be appreciated that the above methods may be carried out on conventional hardware suitably adapted as applicable by software instruction or by the inclusion or substitution of dedicated hardware.

Thus the required adaptation to existing parts of a conventional equivalent device may be implemented in the form of a computer program product comprising processor implementable instructions stored on a non-transitory machine-readable medium such as a floppy disk, optical disk, hard disk, solid state disk, PROM, RAM, flash memory or any combination of these or other storage media, or realised in hardware as an ASIC (application specific integrated circuit) or an FPGA (field programmable gate array) or other configurable circuit suitable to use in adapting the conventional equivalent device. Separately, such a computer program may be transmitted via data signals on a network such as an Ethernet, a wireless network, the Internet, or any combination of these or other networks.

Referring to FIG. 1, the methods and techniques described herein may be implemented on conventional hardware such as an entertainment system 10 that generates images from virtual scenes. An example of such an entertainment system 10 is a computer or console such as the Sony® PlayStation 5 ® (PS5).

The entertainment system 10 comprises a central processor 20. This may be a single or multi core processor, for example comprising eight cores as in the PS5. The entertainment system also comprises a graphical processing unit or GPU 30. The GPU can be physically separate to the CPU, or integrated with the CPU as a system on a chip (SoC) as in the PS5.

The entertainment device also comprises RAM 40, and may either have separate RAM for each of the CPU and GPU, or shared RAM as in the PS5. The or each RAM can be physically separate, or integrated as part of an SoC as in the PS5. Further storage is provided by a disk 50, either as an external or internal hard drive, or as an external solid state drive, or an internal solid state drive as in the PS5.

The entertainment device may transmit or receive data via one or more data ports 60, such as a USB port, Ethernet® port, WiFi® port, Bluetooth® port or similar, as appropriate. It may also optionally receive data via an optical drive 70.

Interaction with the system is typically provided using one or more handheld controllers 80, such as the DualSense® controller in the case of the PS5.

Audio/visual outputs from the entertainment device are typically provided through one or more A/V ports 90, or through one or more of the wired or wireless data ports 60.

Where components are not integrated, they may be connected as appropriate either by a dedicated data link or via a bus 100.

Accordingly, in a summary embodiment of the present description, an entertainment device (such as a Sony® Playstation 5 ® or similar), comprises the following.

Firstly, a graphics processing unit (such as GPU 30, optionally in conjunction with CPU 20) configured (for example by suitable software instruction) to render a pixel at a viewpoint within an image of a virtual scene comprising a first element having a predetermined surface at a position within that scene, as described elsewhere herein.

Secondly, a machine learning processor (such as GPU 30, optionally in conjunction with CPU 20) configured (for example by suitable software instruction) to provide the position and a direction based on the viewpoint to a machine learning system previously trained to predict a factor that, when combined with a distribution function that characterises an interaction of light with the predetermined surface, generates a pixel value corresponding to the first element of the virtual scene as illuminated at the position, as described elsewhere herein.

The graphics processing unit is configured (again for example by suitable software instruction) to combine the predicted factor from the machine learning system with the distribution function to generate the pixel value corresponding to the illuminated first element of the virtual scene at the position, as described elsewhere herein.

Further, the graphics processing unit is also configured (again for example by suitable software instruction) to incorporate the pixel value into a rendered image for display, as described elsewhere herein.

It will be appreciated that the above hardware may similarly be configured to carry out the methods and techniques described herein, such as that:

-   -   the entertainment device comprises a plurality of machine         learning processors (e.g. respective processors, theads and/or         shaders of a GPU and/or CPU) running respective machine learning         systems each trained for one of a plurality of contributing         components of the image (e.g. diffuse, specular, coat, etc),         where a respective distribution function is used for each of the         plurality of contributing components of the image, and the         graphics processing unit is configured (again for example by         suitable software instruction) to combine the respective         generated pixel values to create the pixel value incorporated         into the rendered image for display, as described elsewhere         herein; and     -   the or each machine learning system is a neural network, where         an input to a first portion of the neural network comprises the         position, and an input the a second portion of the neural         network comprises the output of the first portion and the         direction.

Similarly, in another summary embodiment of the present invention, an entertainment device (such as a Sony® Playstation 5 ® or similar), comprises the following.

Firstly, a graphics processing unit (such as GPU 30, optionally in conjunction with CPU 20) configured (for example by suitable software instruction) to render a pixel at a viewpoint within an image of a virtual scene comprising a first element having a predetermined surface at a position within that scene, as described elsewhere herein.

Secondly, a requesting processor (such as CPU 20) configured (for example by suitable software instruction) to obtain a machine learning system previously trained to predict a factor that, when combined with a distribution function that characterises an interaction of light with the predetermined surface, generates a pixel value corresponding to the first element of the virtual scene as illuminated at the position, as described elsewhere herein.

The requesting processor is further configured (for example by suitable software instruction) to obtain the machine learning system by identifying a current or anticipated state of an application determining the virtual scene to be rendered, requesting a download of a machine learning system corresponding to the current or anticipated state, from among a plurality of machine learning systems corresponding to a plurality of states of the application, accessible via a remote server, and then download (or equivalently stream) the requested machine learning system (e.g. via the remote server), as described elsewhere herein.

Thirdly, a machine learning processor (such as GPU 30, optionally in conjunction with CPU 20) configured (for example by suitable software instruction) to provide the position and a direction based on the viewpoint to the machine learning system, as described elsewhere herein.

The graphic processing unit is further configured (for example by suitable software instruction) to combine the predicted factor from the machine learning system with the distribution function to generate the pixel value corresponding to the illuminated first element of the virtual scene at the position, as described elsewhere herein, and the graphic processing unit is also further configured to incorporate the pixel value into a rendered image for display, as described elsewhere herein.

It will be appreciated that the above hardware may similarly be configured to carry out the methods and techniques described herein.

The foregoing discussion discloses and describes merely exemplary embodiments of the present invention. As will be understood by those skilled in the art, the present invention may be embodied in other specific forms without departing from the spirit or essential characteristics thereof. Accordingly, the disclosure of the present invention is intended to be illustrative, but not limiting of the scope of the invention, as well as other claims. The disclosure, including any readily discernible variants of the teachings herein, defines, in part, the scope of the foregoing claim terminology such that no inventive subject matter is dedicated to the public. 

1. An image rendering method for an entertainment device for rendering a pixel at a viewpoint, comprising the steps of: for a first element of a virtual scene, having a predetermined surface at a position within that scene, obtaining a machine learning system previously trained to predict a factor that, when combined with a distribution function that characterises an interaction of light with the predetermined surface, generates a pixel value corresponding to the first element of the virtual scene as illuminated at the position; providing the position and a direction based on the viewpoint to the machine learning system; combining the predicted factor from the machine learning system with the distribution function to generate the pixel value corresponding to the illuminated first element of the virtual scene at the position; and incorporating the pixel value into a rendered image for display; wherein the obtaining step comprise: identifying a current or anticipated state of an application determining the virtual scene to be rendered; requesting a download of a machine learning system corresponding to the current or anticipated state, from among a plurality of machine learning systems corresponding to a plurality of states of the application, accessible via a remote server; and download the requested machine learning system.
 2. An image rendering method according to claim 1 in which the current or anticipated state of the application comprises a virtual location.
 3. An image rendering method according to claim 1 in which the current or anticipated state of the application comprises one or more of: i. a notional time within the virtual scene; ii. a lighting condition; and iii. a state of a dynamic object.
 4. An image rendering method according to claim 1 in which the requesting step comprises formulating a file name or file location of the machine learning system based upon the current or anticipated state of the application.
 5. An image rendering method according to claim 1 in which the requesting step comprises requesting a plurality of machine learning systems respectively corresponding to a plurality of anticipated states of the application.
 6. An image rendering method according to claim 1, in which a state of the application is treated as anticipated if the current application state is within a threshold of a boundary with that state.
 7. An image rendering method according to claim 1, in which, responsive to the proximity of the current application state to a boundary between two or more application states, the outputs of the corresponding two or more machine learning systems are blended.
 8. An image rendering method according to claim 1, in which if upon request no machine learning system corresponds to the current or anticipated state, the method comprises: selecting a machine learning system closely corresponding to the current or anticipated state; and training a copy of the selected machine learning system on image data corresponding to the current or anticipated state.
 9. An image rendering method according to claim 8, in which the step of training comprises: uploading image data from the entertainment device to the remote server; training the copy of the selected machine learning system at the remote server; and associating the trained copy with the current or anticipated state.
 10. An image rendering method according to claim 8, in which the step of training comprises: downloading the copy of the selected machine learning system from the remote server; training the copy of the selected machine learning system at the entertainment device; uploading the trained copy from the entertainment device to the remote server; and associating the trained copy with the current or anticipated state.
 11. An image rendering method according to claim 10, in which the training is performed during operation of the application based on image data rendered by the application using an alternative rendering method.
 12. An image rendering method according to claim 10, in which the training is performed separately to the operation of the application based on image data obtained from an image buffer used to record video clips of rendered image data.
 13. The image rendering method of claim 1, in which the step of incorporating the pixel value into a rendered image for display comprises: using respective machine learning systems that have each been trained for one of a plurality of contributing components of the image; using a respective distribution function for each of the plurality of contributing components of the image; and combining the respective generated pixel values to create a final combined pixel value incorporated into the rendered image for display.
 14. A non-transitory, computer readable storage medium containing a computer program comprising computer executable instructions, which when executed by a computer system, causes the computer system to perform an image rendering method for an entertainment device for rendering a pixel at a viewpoint by carrying out actions, comprising: for a first element of a virtual scene, having a predetermined surface at a position within that scene, obtaining a machine learning system previously trained to predict a factor that, when combined with a distribution function that characterises an interaction of light with the predetermined surface, generates a pixel value corresponding to the first element of the virtual scene as illuminated at the position; providing the position and a direction based on the viewpoint to the machine learning system; combining the predicted factor from the machine learning system with the distribution function to generate the pixel value corresponding to the illuminated first element of the virtual scene at the position; and incorporating the pixel value into a rendered image for display; wherein the obtaining step comprise: identifying a current or anticipated state of an application determining the virtual scene to be rendered; requesting a download of a machine learning system corresponding to the current or anticipated state, from among a plurality of machine learning systems corresponding to a plurality of states of the application, accessible via a remote server; and download the requested machine learning system.
 15. An entertainment device, comprising a graphics processing unit configured to render a pixel at a viewpoint within an image of a virtual scene comprising a first element having a predetermined surface at a position within that scene; a requesting processor configured to obtain a machine learning system previously trained to predict a factor that, when combined with a distribution function that characterises an interaction of light with the predetermined surface, generates a pixel value corresponding to the first element of the virtual scene as illuminated at the position; a machine learning processor configured to provide the position and a direction based on the viewpoint to the machine learning system; the graphic processing unit being configured to combine the predicted factor from the machine learning system with the distribution function to generate the pixel value corresponding to the illuminated first element of the virtual scene at the position; and the graphic processing unit being configured to incorporate the pixel value into a rendered image for display; and wherein the requesting processor is configured to: identify a current or anticipated state of an application determining the virtual scene to be rendered; request a download of a machine learning system corresponding to the current or anticipated state, from among a plurality of machine learning systems corresponding to a plurality of states of the application, accessible via a remote server; and download the requested machine learning system. 